//# include <iostream>
//
//using namespace std;

//int main()
//{
//	// 写一个程序打印出1~100之间的奇数
//	// 不能被2整除的是奇数
//	
//	for (int i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 1)
//		{
//			cout << i << endl;
//		}
//	}
//	return 0;
//}

//题目2：打印九九乘法表
//int main()
//{
//	//定义变量i代表行
//	//定义变量j代表列
//	int i = 0;
//	int j = 0;
//	for (i = 1; i <= 9; i++)
//	{
//		for (j = 1; j <= i; j++)
//		{
//			cout << i << "*" << j << "=" << i * j << " ";
//		}
//		cout << endl;
//	}
//
//	return 0;
//}

//题目3：打印素数
//int main() {
//
//	for (int i = 100; i <= 200; i++)
//	{
//		bool flag = true;
//		for (int j = 2; j < i; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = false;
//				break;
//			}
//
//			
//		}
//		if (flag)
//		{
//			cout << i << endl;
//		}
//	}
//	return 0;
//}

//题目4：判定是否是三角形，接着判断是不是等边三角形，如果是等腰三角形，否则就是普通三角形
//int main()
//{
//	//三角形判断方法：a+b>c,a+c>b,b+c>a
//	//如果是三角形，等边三角形是三边相等
//	//等腰三角形：两边相等，但不等于第三边
//	//普通三角形，三边不相等
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	cin >> a >> b >> c;
//	//先判定是不是三角形
//	if ((a + b) > c && (a + c) > b && (b + c) > a)
//	{
//		//如果是三角形，判断是不是等腰三角形
//		if (a == b && b == c)
//			cout << "等边三角形" << endl;
//		else if ((a == b) || (a == c) || (b == c))
//			cout << "等腰三角形" << endl;
//		else
//			cout << "普通三角" << endl;
//	}
//	else
//		cout << "不是三角形" << endl;
//	return 0;
//}

//打印100到200之间的素数

//int main()
//{
//	//我是否需要一个循环从100到200
//	//怎么判断素数
//	//素数是只可以被1和自身整除的数字
//	//如果有一个数字x我们想知道是不是素数的话，那么1和他自身就是判断条件
//	//如果从2到x-1的数字当中有任何一个数字可以被整除，那么x就不是素数
//	//当x是偶数的时候，那么他一定不是素数，因此循环中可以跳过每个偶数
//	int i = 0;
//	for (i = 100; i <= 200; i++)
//	{
//		//循环从100开始，直到小于等于200结束
//		//那么我们想如果从2到x-1的数字当中有任何一个数字可以被整除，那么x就不是素数
//		//我可以定义一个变量j，从2到i-1之间判断，不断被i整除，判断是不是素数
//		int j = 0;
//		int flag = 1;
//		for (j = 2; j < i; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;
//				break;
//			}
//		}
//		//到这里为止所有的i从100到200都判断完成，不断试除2到i-1的数字
//		//循环结束，如果是素数就打印，如果不是的话那我就break跳出当前循环
//		//flag=0
//		if (flag == 1)
//			cout << i << endl;
//	}
//	return 0;
//}

//怎么优化这个代码呢
//int main()
//{
//	int i = 0;
//	//偶数不是素数的时候，就可以直接跳过了
//	for (i = 101; i <= 200; i += 2)
//	{
//		int j = 0;
//		bool flag = true;
//		for (j = 2; j < i; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = false;
//				break;
//			}
//		}
//		if (flag)
//		{
//			cout << i << endl;
//		}
//	}
//
//	return 0;
//}

//int main()
//{
//	//1.先判定是不是三角形
//	// 
//	//2.如果是的话，再接着判断
//	//3.如果是等边三角形就输出
//	//4.如果是等腰三角形也输出
//	//5.如果都不是就输出普通三角形
//	//6.如果连三角形都不是的话直接输出不是三角形
//	//我先定义三个变量abc分别代表三角形的三条线
//	//cin接收用户的数据并且传入到abc变量中
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	cin >> a >> b >> c;
//	//接下来我要判定是不是三角形
//	if ((a + b) > c && (a + c) > b && (b + c) > a)
//	{
//		//如果是三角形的话那我接着判断
//		//先判断是否是等边三角形
//		if ((a == b) && (b == c))
//			cout << "等边三角形" << endl;
//		//接着判断是不是等腰三角形
//		else if ((a == b) || (a == c) || (b == c))
//			cout << "等腰三角形" << endl;
//		//如果既不是等腰也不是等边，那就是普通三角形
//		else
//			cout << "普通三角形" << endl;
//	}
//	else
//		//如果既不是普通三角形，也不是等腰，也不是等边，那他甚至都不是三角形
//		cout << "不是三角形" << endl;
//	return 0;
//}

//计算两个数字最大的公约数

//int gcd(int a, int b)
//{
//	//首先a和b必须是整数，并且是正整数，那我的判断条件就可以是b不等于0
//	//如果b不等于0，那我把b的值赋给a，然后我把a%b的结果复制给b
//	//36%24 = 12, 把b的值给，a=24 , b=12
//	//24%12 = 0,直接返还a，但是要交换值，a=12，b=0.
//	return (b == 0) ? a : gcd(b, a % b);
//}
//
//int main()
//{
//	//要计算两个数字最大的公约数
//	//那两个数字我是不是要定义两个变量a和b用于储存用户输入的值
//	//欧几里得算法，如果a和b是正整数，而且a大于b，则a和b的最大公约数等于b和a%b(a%b所得的余数）和最大公约数
//	//那么我们是不是首先要判断a是否大于b，如果a不大于b的话我们是不是要写代码处理
//	int a = 0;
//	int b = 0;
//	cin >> a >> b;
//	cout << "a和b的最大公约数是：" << gcd(a, b) << endl;
//	return 0;
//}

//计算两个数字中的最大公倍数

//int gcd(int m, int n)
//{
//	return (n == 0) ? m : gcd(n, m % n);
//}
//
//int lcm(int m, int n)
//{
//	return (m / gcd(m, n)) * n;
//}
//
//int main()
//{
//	int m, n;
//	cin >> m >> n;
//	int z = lcm(m, n);
//	cout << z << endl;
//	
//	return 0;
//}

//int main()
//{
//	//计算1/1-1/2+1/3-1/4+1/5-…+1/99-1/100的值，并打印出结果
//	//那么其实就是oddnumber的时候就加，而even的时候就要去剪掉
//	int i = 1;
//	double sum = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		//首先判断是odd还是evennumber
//		if (i % 2 == 0)
//			sum += 1.0 / i;
//		else
//			//如果不是odd，那就是even这时候需要减掉
//			sum -= 1.0 / i;
//	}
//	cout << sum << endl;
//	return 0;
//}

//输⼊10个整数，写代码找出其中最⼤值和最⼩值，计算最⼤值和最⼩值的差，并打印出差值结果
//int main()
//{
//	//如果要存放十个整数我们是否可以写一个整形数组储存十个整数
//	int arr[10] = { 0 };
//	//把用户输入的十个数字存放到数组中，那么我们是否可以定义一个循环存放到数组中
//	for (int i = 0; i < 10; i++)
//	{
//		cin >> arr[i];
//	}
//	//存放数组中以后接下来要判断最大值和最小值
//	//如何找到最大值？
//	//那么我是否可以设置一个变量min和max分别指向arr[0]下标的第一个数字呢？
//	int max = arr[0];
//	int min = arr[0];
//	//如果min和max都指向了数组中第一个元素的话，那么数组就剩下了九个元素
//	for (int i = 1; i < 10; i++)
//	{
//		//假设我一个元素是2，第2个元素是3，那max小于第二个元素，这时候我把更大的数值赋给max
//		//接着往下判断，直到循环结束没有比max还大的数值为止
//		if (arr[i] > max)
//			max = arr[i];
//		//同样的道理，如果我第一个元素是2，第二个元素是1，那第二个元素比min还小，那我把1赋值给min
//		//接着判断，直到循环结束，直到min是最小的数值为止
//		if (arr[i] < min)
//			min = arr[i];
//	}
//	//循环结束，已经找到了max和min的值，那么我可以打印了
//	cout << max << endl;
//	cout << min << endl;
//	return 0;
//}

//这个代码我还能不能优化？
//int main()
//{
//	//如果要存放十个整数我们是否可以写一个整形数组储存十个整数
//	int arr[10] = { 0 };
//	//把用户输入的十个数字存放到数组中，那么我们是否可以定义一个循环存放到数组中
//	for (int i = 0; i < 10; i++)
//	{
//		cin >> arr[i];
//	}
	//存放数组中以后接下来要判断最大值和最小值
	//如何找到最大值？
	//那么我是否可以设置一个变量min和max分别指向arr[0]下标的第一个数字呢？
//	int max = arr[0];
//	int min = arr[0];
//	//如果min和max都指向了数组中第一个元素的话，那么数组就剩下了九个元素
//	for (int i = 1; i < 10; i++)
//	{
//		//假设我一个元素是2，第2个元素是3，那max小于第二个元素，这时候我把更大的数值赋给max
//		//接着往下判断，直到循环结束没有比max还大的数值为止
//		//我这里能不能用三木运算符来表达？
//		/*if (arr[i] > max)
//			max = arr[i];*/
//		max = (arr[i] > max) ? arr[i] : max;
//		//同样的道理，如果我第一个元素是2，第二个元素是1，那第二个元素比min还小，那我把1赋值给min
//		//接着判断，直到循环结束，直到min是最小的数值为止
//		/*if (arr[i] < min)
//			min = arr[i];*/
//		min = (arr[i] < min) ? arr[i] : min;
//	}
//	//循环结束，已经找到了max和min的值，那么我可以打印了
//	cout << max << endl;
//	cout << min << endl;
//	return 0;
//}

//输⼊10个整数，然后使⽤冒泡排序对数组内容进⾏升序排序，然后打印数组的内容

//void test()
//{
//	cout << "hehe" << endl;
//}
//
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < sz; i++)
//	{
//		arr[i] = i + 1;
//	}
//	test();
//
//	for (i = 0; i < sz; i++)
//	{
//		cout << arr[i] << endl;
//	}
//	return 0;
//}

//求1到10的阶乘
//int main()
//{
//	int n = 0;
//	int ret = 1;
//	int sum = 0;
//	for (n = 1; n <= 10; n++)
//	{
//		for (int i = 1; i <= n; i++)
//		{
//			ret = ret * i;
//		}
//		sum += ret;
//	}
//	cout << sum << endl;
//	return 0;
//}

//找出bug
//int main()
//{
//	int i = 0;
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	for (i = 0; i <= 12; i++)
//	{
//		arr[i] = 0;
//		cout << "hehe" << endl;
//	}
//	return 0;
//}

//void指针
//空或者无具体类型的指针
//用于接收任意类型的指针
//举例
//int main()
//{
//	int a = 10;
//	/*int* p = &a;*/
////  int       int  都属于同一个类型的数据
//	//但如果有一天我不知道别人给我传进来的数据类型是什么的时候呢？
//	void* p = &a;
//	//void类型的指针无法进行+-或者解引用的操作
//	/**p = 20;*/
//
//
//
//	return 0;
//}

//指针的运算

//int main()
//{
//	//指针最主要的目的就是为了访问内存
//	//指针+-整数
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = &arr[0];
//	int sz = sizeof(arr) / sizeof(arr[0]);//10个元素
//	for (int i = 0; i < sz; i++)
//	{
//		cout << arr[i] << " ";
//	}
//	return 0;
//}

//int main()
//{
//	//用指针的方法去打印数组	
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = &arr[0];
//	int sz = sizeof(arr) / sizeof(arr[0]);//10个元素
//	for (int i = 0; i < sz; i++)
//	{
//		cout << *(p + i) << " ";
//	}
//	return 0;
//}

//指针-指针的前提是： 两个指针指向同一块空间
//指针减去指针得到的是两个之间的元素个数！！！！ 

//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	cout << &arr[9] - &arr[0];
//
//	return 0;
//}

//指针-指针的应用

//size_t my_strlen(char *p)
//{
//	char* q = p;
//	while (*q != '\0')
//	{
//		q++;
//	}
//	return q - p;
//}
//
//int main()
//{
//	char arr[] = "abcdefg"; //定义了char类型的数组
//	size_t len = my_strlen(arr);
//	cout << len << endl;
//	return 0; 
//}

//指针关系运算
//地址比较大小

//int main()
//{
//	// const的意思就是不变/常属性
//	const int n = 10; //n的值是不能修改的
//	//n在这里也被称为长变量
//	n = 20; // 这里编译器就会报错
//	// n的本质是变量但不可以被修改
//
//	return 0; 
//}


//int main()
//{
//	//当我们用const固定一个值的时候我们用指针是否可改变const的值呢？
//	const int a = 10;
//	
//	//当const在星号的左边  const int * p
//	// const int* p = &a;
//	// const限制的是 *p, 也就是指向的内容不能通过p修改了
//	//当const在星号的右边 int * const p
//
//	*p = 200;
//	cout << a << endl;
//
//
//	return 0;
//}

//void swap(int *a, int *b)
//{
//	int temp = 0;
//	temp = *a;
//	*a = *b;
//	*b = temp;
//}
//
////冒泡排序
//int main()
//{
//	int a = 10;
//	int b = 20;
//	swap(&a, &b);
//	cout << a << endl;
//	cout << b << endl;
//
//	return 0;
//}

//void swap(int arr[], int sz)
//{
//	//我们首先知道了sz里面储存的是元素个数
//	//那我们是否需要知道假设有sz个元素，但如果两两对比的话有多少次对比呢？(sz-1)
//	//但我们知道一次排序完成实际上是排序了一个数字而已
//	//那下次循环我们需要排列的次数是多少呢？
//	//第一次是10个元素-1 等于9次对比，第二次就是9个元素，-1就是八次对比
//	//如果看出规律了，下次排序的次数就是n个元素-1再减去当此循环i-1；
//	//当i=0，n-1-i= 9, i++,下一次就是9个元素，9个元素-1次对比因为少了一个数字，再减去i
//	//这样就得到了9个元素-1就是8次对比
//	for (int i = 0; i < sz - 1; i++)
//	{
//		for (int j = 0; j < sz - 1 - i; j++)
//		{
//			//既然我知道了对比次数和每次都会少一个元素-i的对比次数
//			//那我们现在要知道如果第一个数字比第二个数字大的话第一个元素就右移动
//			int temp = 0;
//			if (arr[j] > arr[j + 1])
//			{
//				temp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = temp;
//			}
//		}
//	}
//}

////打印已经排好顺序的数组
//void print(int arr[], int sz)
//{
//	for (int j = 0; j < sz; j++)
//	{
//		cout << arr[j] << " ";
//	}
//}
//
//int main()
//{
//	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
//	//我得知道一个数组中有多少个元素个数
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	swap(arr,sz);
//	print(arr, sz);
//	return 0;
//}

